# -*- coding: utf-8 -*-
"""
MES系统对话框工具类
提供统一、易用、功能丰富的对话框接口，隐藏Qt底层实现细节
支持信息、警告、错误、询问、自定义按钮等多种对话框类型
"""
from typing import Optional, List, Union, Tuple
from PySide6.QtWidgets import (QMessageBox, QApplication, QInputDialog,
                               QFileDialog, QProgressDialog, QLineEdit, QPushButton)
from PySide6.QtGui import QIcon, QPixmap
from PySide6.QtCore import Qt, QThread, Signal
import sys
import logging
import os

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# --- 常量定义 ---
DIALOG_TITLE = "MES系统"
DEFAULT_ICON_PATH = ":/image/resource/images/未来.png"
DEFAULT_BUTTONS = ["确定", "放弃"]  # 统一默认按钮文本
DEFAULT_STYLE_SHEET = """
QMessageBox {
    font-size: 14px;
    min-width: 300px;
    max-width: 600px;
}
QPushButton {
    min-width: 80px;
    min-height: 30px;
    font-size: 14px;
}
QLabel {
    font-size: 14px;
}
QInputDialog {
    font-size: 14px;
    min-width: 350px;
}
QProgressDialog {
    font-size: 14px;
    min-width: 350px;
}
"""

# --- 导出枚举和类型别名 ---
StandardButton = QMessageBox.StandardButton
ButtonRole = QMessageBox.ButtonRole
IconType = Union[QMessageBox.Icon, QIcon, QPixmap, str]
DialogResult = Union[StandardButton, int, str, bool, None]
EchoMode = QLineEdit.EchoMode  # 导出输入回显模式枚举，方便外部使用


class DialogUtils:
    """
    增强版对话框工具类，提供丰富的对话框功能

    核心特性：
    - 自动管理QApplication实例，无需手动创建
    - 支持自定义图标、样式、按钮、模态状态等
    - 提供输入框、文件选择、进度对话框等扩展功能
    - 完善的异常处理和日志记录
    - 统一的返回值类型和错误处理
    - 所有按钮统一为"确定"/"放弃"（替代OK/Cancel）
    - 详细信息按钮本地化（显示详细信息/隐藏详细信息）
    """

    @staticmethod
    def _get_app_instance() -> QApplication:
        """确保QApplication实例存在"""
        app = QApplication.instance()
        if app is None:
            app = QApplication(sys.argv)
            # 设置全局应用图标
            try:
                app_icon = QIcon(DEFAULT_ICON_PATH)
                if not app_icon.isNull():
                    app.setWindowIcon(app_icon)
            except Exception as e:
                logger.warning(f"设置应用图标失败: {e}")
        return app

    @staticmethod
    def _load_icon(icon: Optional[IconType]) -> Optional[QIcon]:
        """加载图标，支持多种输入类型"""
        if icon is None:
            return None

        if isinstance(icon, QMessageBox.Icon):
            # 转换为QIcon
            msg_box = QMessageBox()
            return msg_box.style().standardIcon(
                QMessageBox.style().SP_MessageBoxIcon + icon.value
            )
        elif isinstance(icon, QIcon):
            return icon
        elif isinstance(icon, QPixmap):
            return QIcon(icon)
        elif isinstance(icon, str):
            # 支持资源路径或文件路径
            if os.path.exists(icon) or icon.startswith(':'):
                qicon = QIcon(icon)
                if qicon.isNull():
                    logger.warning(f"图标加载失败: {icon}")
                    return None
                return qicon
            else:
                logger.warning(f"图标路径无效: {icon}")
                return None
        else:
            logger.warning(f"不支持的图标类型: {type(icon)}")
            return None

    @staticmethod
    def _set_button_texts(msg_box: QMessageBox):
        """统一设置QMessageBox所有按钮的中文文本（包含详细信息按钮）"""
        # 1. 基础标准按钮（优先设置，确保不被覆盖）
        msg_box.setButtonText(StandardButton.Ok, "确定")
        msg_box.setButtonText(StandardButton.Cancel, "放弃")
        msg_box.setButtonText(StandardButton.Yes, "是")
        msg_box.setButtonText(StandardButton.No, "否")
        msg_box.setButtonText(StandardButton.Abort, "中止")
        msg_box.setButtonText(StandardButton.Retry, "重试")
        msg_box.setButtonText(StandardButton.Ignore, "忽略")
        msg_box.setButtonText(StandardButton.YesToAll, "全部是")
        msg_box.setButtonText(StandardButton.NoToAll, "全部否")
        msg_box.setButtonText(StandardButton.Apply, "应用")
        msg_box.setButtonText(StandardButton.Reset, "重置")

        # 2. 详细信息按钮本地化（显示/隐藏详细信息）
        QApplication.processEvents()
        for btn in msg_box.buttons():
            if btn.text() in ["Show Details...", "Hide Details...", "显示详细信息", "隐藏详细信息"]:
                # 强制设置初始文本为"显示详细信息"
                btn.setText("显示详细信息")

                # 连接按钮点击事件，切换显示/隐藏文本
                def toggle_details_text():
                    nonlocal btn
                    if btn.text() == "显示详细信息":
                        btn.setText("隐藏详细信息")
                    else:
                        btn.setText("显示详细信息")

                btn.clicked.connect(toggle_details_text)
                break

    @staticmethod
    def _create_base_dialog(
            icon_type: QMessageBox.Icon,
            title: str = DIALOG_TITLE,
            text: str = "",
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET
    ) -> QMessageBox:
        """创建基础对话框并配置通用属性"""
        app = DialogUtils._get_app_instance()

        msg_box = QMessageBox()
        msg_box.setWindowTitle(title)
        msg_box.setText(text)

        # 设置详细文本（支持折叠/展开）
        if detailed_text:
            msg_box.setDetailedText(detailed_text)

        # 设置图标
        if icon:
            qicon = DialogUtils._load_icon(icon)
            if qicon:
                msg_box.setWindowIcon(qicon)
                msg_box.setIconPixmap(qicon.pixmap(64, 64))
        else:
            msg_box.setIcon(icon_type)
            # 尝试加载默认窗口图标
            try:
                default_icon = QIcon(DEFAULT_ICON_PATH)
                if not default_icon.isNull():
                    msg_box.setWindowIcon(default_icon)
            except Exception as e:
                logger.debug(f"加载默认图标失败: {e}")

        # 设置模态/非模态
        msg_box.setModal(modal)

        # 设置样式表
        if style_sheet:
            msg_box.setStyleSheet(style_sheet)

        return msg_box

    @staticmethod
    def info(
            text: str,
            title: str = DIALOG_TITLE,
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET
    ) -> None:
        """
        信息提示框（确定按钮 + 详细信息按钮）

        Args:
            text: 提示文本
            title: 窗口标题（默认：MES系统）
            detailed_text: 详细文本（可折叠，自动显示"显示详细信息"按钮）
            icon: 自定义图标（支持QIcon、QPixmap、路径字符串、QMessageBox.Icon）
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
        """
        try:
            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Information,
                title=title,
                text=text,
                detailed_text=detailed_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )

            # 关键修复：先设置按钮，再强制设置文本（避免覆盖）
            msg_box.setStandardButtons(StandardButton.Ok)
            msg_box.setDefaultButton(StandardButton.Ok)

            # 第一次设置按钮文本
            DialogUtils._set_button_texts(msg_box)

            # 终极保险：直接获取Ok按钮并强制设置文本
            ok_button = msg_box.button(StandardButton.Ok)
            if ok_button:
                ok_button.setText("确定")

            # 如果有详细文本，确保详细按钮文本正确
            if detailed_text:
                QApplication.processEvents()
                for btn in msg_box.buttons():
                    if "Details" in btn.text() or "详细信息" in btn.text():
                        btn.setText("显示详细信息")
                        break

            msg_box.exec() if modal else msg_box.show()
        except Exception as e:
            logger.error(f"创建信息对话框失败: {e}", exc_info=True)

    @staticmethod
    def warn(
            text: str,
            title: str = f"{DIALOG_TITLE} - 警告",
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET,
            buttons: Tuple[StandardButton, ...] = (StandardButton.Yes, StandardButton.No),
            default_button: Optional[StandardButton] = StandardButton.No
    ) -> StandardButton:
        """
        警告对话框（支持自定义标准按钮）

        Args:
            text: 警告文本
            title: 窗口标题（默认：MES系统 - 警告）
            detailed_text: 详细文本（可折叠）
            icon: 自定义图标
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
            buttons: 标准按钮组合（默认：Yes/No）
            default_button: 默认选中按钮（默认：No）

        Returns:
            StandardButton: 用户点击的按钮
        """
        try:
            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Warning,
                title=title,
                text=text,
                detailed_text=detailed_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )
            msg_box.setStandardButtons(StandardButton(0))  # 清空默认按钮
            for btn in buttons:
                msg_box.addButton(btn)
            if default_button and default_button in buttons:
                msg_box.setDefaultButton(default_button)
            DialogUtils._set_button_texts(msg_box)
            return msg_box.exec() if modal else StandardButton.No
        except Exception as e:
            logger.error(f"创建警告对话框失败: {e}", exc_info=True)
            return StandardButton.No

    @staticmethod
    def error(
            text: str,
            title: str = f"{DIALOG_TITLE} - 错误",
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET
    ) -> None:
        """
        错误对话框（只有确定按钮）

        Args:
            text: 错误文本
            title: 窗口标题（默认：MES系统 - 错误）
            detailed_text: 详细错误信息（可折叠，建议包含异常详情）
            icon: 自定义图标
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
        """
        try:
            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Critical,
                title=title,
                text=text,
                detailed_text=detailed_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )
            msg_box.setStandardButtons(StandardButton.Ok)
            msg_box.setDefaultButton(StandardButton.Ok)

            # 强制设置确定按钮文本
            ok_button = msg_box.button(StandardButton.Ok)
            if ok_button:
                ok_button.setText("确定")

            msg_box.exec() if modal else msg_box.show()
        except Exception as e:
            logger.error(f"创建错误对话框失败: {e}", exc_info=True)

    @staticmethod
    def question(
            text: str,
            title: str = f"{DIALOG_TITLE} - 询问",
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET,
            buttons: Tuple[StandardButton, ...] = (StandardButton.Ok, StandardButton.Cancel),
            default_button: Optional[StandardButton] = StandardButton.Cancel
    ) -> StandardButton:
        """
        询问对话框（确定/放弃按钮）

        Args:
            text: 询问文本
            title: 窗口标题（默认：MES系统 - 询问）
            detailed_text: 详细文本（可折叠）
            icon: 自定义图标
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
            buttons: 标准按钮组合（默认：确定/放弃）
            default_button: 默认选中按钮（默认：放弃）

        Returns:
            StandardButton: 用户点击的按钮
        """
        try:
            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Question,
                title=title,
                text=text,
                detailed_text=detailed_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )
            msg_box.setStandardButtons(StandardButton(0))  # 清空默认按钮
            for btn in buttons:
                msg_box.addButton(btn)
            if default_button and default_button in buttons:
                msg_box.setDefaultButton(default_button)
            else:
                msg_box.setDefaultButton(StandardButton.Cancel)

            # 强制设置按钮文本
            DialogUtils._set_button_texts(msg_box)
            ok_button = msg_box.button(StandardButton.Ok)
            cancel_button = msg_box.button(StandardButton.Cancel)
            if ok_button:
                ok_button.setText("确定")
            if cancel_button:
                cancel_button.setText("放弃")

            return msg_box.exec() if modal else StandardButton.Cancel
        except Exception as e:
            logger.error(f"创建询问对话框失败: {e}", exc_info=True)
            return StandardButton.Cancel

    @staticmethod
    def about(
            text: str,
            title: str = f"{DIALOG_TITLE} - 关于",
            version: str = "",
            copyright: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET
    ) -> None:
        """
        关于对话框（只有确定按钮）

        Args:
            text: 关于文本
            title: 窗口标题（默认：MES系统 - 关于）
            version: 版本信息
            copyright: 版权信息
            icon: 自定义图标（建议使用应用Logo）
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
        """
        try:
            # 构建完整的关于文本
            full_text = text
            if version:
                full_text += f"\n\n版本: {version}"
            if copyright:
                full_text += f"\n\n{copyright}"

            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Information,
                title=title,
                text=full_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )
            msg_box.setStandardButtons(StandardButton.Ok)
            msg_box.setDefaultButton(StandardButton.Ok)

            # 强制设置确定按钮文本
            ok_button = msg_box.button(StandardButton.Ok)
            if ok_button:
                ok_button.setText("确定")

            msg_box.exec() if modal else msg_box.show()
        except Exception as e:
            logger.error(f"创建关于对话框失败: {e}", exc_info=True)

    @staticmethod
    def custom_buttons(
            text: str,
            buttons: List[str] = None,
            title: str = DIALOG_TITLE,
            detailed_text: str = "",
            icon: Optional[IconType] = None,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET,
            default_button_index: int = 0,
            button_roles: List[ButtonRole] = None
    ) -> Tuple[int, str]:
        """
        自定义按钮对话框（默认：确定/放弃）

        Args:
            text: 对话框文本
            buttons: 按钮文本列表（默认：["确定", "放弃"]）
            title: 窗口标题
            detailed_text: 详细文本（可折叠）
            icon: 自定义图标
            modal: 是否模态窗口（默认：True）
            style_sheet: 自定义样式表
            default_button_index: 默认选中按钮索引（默认：0）
            button_roles: 按钮角色列表（与buttons对应，默认：全部AcceptRole）

        Returns:
            Tuple[int, str]: (按钮索引, 按钮文本)，取消或失败返回(-1, "")
        """
        try:
            buttons = buttons or DEFAULT_BUTTONS.copy()  # 强制使用["确定", "放弃"]
            if not buttons:
                logger.warning("自定义按钮列表不能为空")
                return -1, ""

            # 确保按钮角色列表长度匹配
            if button_roles is None:
                button_roles = [ButtonRole.AcceptRole] * len(buttons)
            else:
                button_roles = button_roles[:len(buttons)]
                # 补充缺失的角色
                while len(button_roles) < len(buttons):
                    button_roles.append(ButtonRole.AcceptRole)

            msg_box = DialogUtils._create_base_dialog(
                QMessageBox.Icon.Information,
                title=title,
                text=text,
                detailed_text=detailed_text,
                icon=icon,
                modal=modal,
                style_sheet=style_sheet
            )

            # 添加自定义按钮
            button_refs = []
            for btn_text, role in zip(buttons, button_roles):
                btn = msg_box.addButton(btn_text, role)
                button_refs.append(btn)

            # 设置默认按钮
            if 0 <= default_button_index < len(button_refs):
                msg_box.setDefaultButton(button_refs[default_button_index])

            # 执行对话框
            if modal:
                msg_box.exec()
                clicked_btn = msg_box.clickedButton()
                if clicked_btn in button_refs:
                    idx = button_refs.index(clicked_btn)
                    return idx, buttons[idx]

            return -1, ""
        except Exception as e:
            logger.error(f"创建自定义按钮对话框失败: {e}", exc_info=True)
            return -1, ""

    @staticmethod
    def input_text(
            prompt: str,
            title: str = f"{DIALOG_TITLE} - 输入",
            default_text: str = "",
            echo_mode: EchoMode = QLineEdit.Normal,
            modal: bool = True,
            style_sheet: str = DEFAULT_STYLE_SHEET
    ) -> Tuple[bool, str]:
        """
        文本输入对话框（确定/放弃按钮）

        Args:
            prompt: 输入提示文本
            title: 窗口标题
            default_text: 默认输入文本
            echo_mode: 输入回显模式（默认：正常显示，可选：Password/NoEcho等）
            modal: 是否模态窗口
            style_sheet: 自定义样式表

        Returns:
            Tuple[bool, str]: (是否确认, 输入文本)
        """
        try:
            app = DialogUtils._get_app_instance()

            dialog = QInputDialog()
            dialog.setWindowTitle(title)
            dialog.setLabelText(prompt)
            dialog.setTextValue(default_text)
            dialog.setTextEchoMode(echo_mode)
            dialog.setModal(modal)
            dialog.setStyleSheet(style_sheet)

            # 强制设置按钮文本
            dialog.setOkButtonText("确定")
            dialog.setCancelButtonText("放弃")

            # 设置窗口图标
            try:
                default_icon = QIcon(DEFAULT_ICON_PATH)
                if not default_icon.isNull():
                    dialog.setWindowIcon(default_icon)
            except Exception:
                pass

            result = dialog.exec() if modal else dialog.show()
            if modal and result == QInputDialog.Accepted:
                return True, dialog.textValue()
            return False, ""
        except Exception as e:
            logger.error(f"创建输入对话框失败: {e}", exc_info=True)
            return False, ""

    @staticmethod
    def select_file(
            title: str = f"{DIALOG_TITLE} - 选择文件",
            filter: str = "所有文件 (*.*)",
            directory: str = "",
            save: bool = False,
            multiple: bool = False
    ) -> Union[str, List[str], None]:
        """
        文件选择对话框（系统默认中文按钮，保持系统一致性）

        Args:
            title: 窗口标题
            filter: 文件过滤器（格式："文本文件 (*.txt);;所有文件 (*.*)"）
            directory: 初始目录
            save: 是否为保存对话框（默认：打开）
            multiple: 是否支持多选（仅打开对话框有效）

        Returns:
            str: 选中的文件路径（单文件）
            List[str]: 选中的文件路径列表（多文件）
            None: 取消选择或失败
        """
        try:
            app = DialogUtils._get_app_instance()

            # 确保初始目录存在
            if directory and not os.path.exists(directory):
                directory = ""

            if save:
                # 保存文件对话框
                file_path, _ = QFileDialog.getSaveFileName(
                    None, title, directory, filter
                )
                return file_path if file_path else None
            else:
                # 打开文件对话框
                if multiple:
                    file_paths, _ = QFileDialog.getOpenFileNames(
                        None, title, directory, filter
                    )
                    return file_paths if file_paths else None
                else:
                    file_path, _ = QFileDialog.getOpenFileName(
                        None, title, directory, filter
                    )
                    return file_path if file_path else None
        except Exception as e:
            logger.error(f"创建文件选择对话框失败: {e}", exc_info=True)
            return None

    @staticmethod
    def select_directory(
            title: str = f"{DIALOG_TITLE} - 选择目录",
            directory: str = ""
    ) -> Optional[str]:
        """
        目录选择对话框（系统默认中文按钮，保持系统一致性）

        Args:
            title: 窗口标题
            directory: 初始目录

        Returns:
            str: 选中的目录路径
            None: 取消选择或失败
        """
        try:
            app = DialogUtils._get_app_instance()

            # 确保初始目录存在
            if directory and not os.path.exists(directory):
                directory = ""

            dir_path = QFileDialog.getExistingDirectory(
                None, title, directory,
                QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks
            )
            return dir_path if dir_path else None
        except Exception as e:
            logger.error(f"创建目录选择对话框失败: {e}", exc_info=True)
            return None

    @staticmethod
    def progress_dialog(
            task_func,
            title: str = f"{DIALOG_TITLE} - 处理中",
            label_text: str = "处理中，请稍候...",
            min_value: int = 0,
            max_value: int = 100,
            modal: bool = True,
            cancelable: bool = True,
            *args, **kwargs
    ) -> Tuple[bool, Optional[any]]:
        """
        进度对话框（放弃按钮）

        Args:
            task_func: 后台任务函数（需通过回调更新进度）
            title: 窗口标题
            label_text: 提示文本
            min_value: 进度最小值
            max_value: 进度最大值
            modal: 是否模态窗口
            cancelable: 是否可取消
            *args, **kwargs: 传递给task_func的参数

        Returns:
            Tuple[bool, any]: (是否成功完成, 任务返回值)
        """

        class WorkerThread(QThread):
            progress_updated = Signal(int)
            finished_signal = Signal(bool, object)

            def __init__(self, func, cancel_flag, *args, **kwargs):
                super().__init__()
                self.func = func
                self.cancel_flag = cancel_flag
                self.args = args
                self.kwargs = kwargs

            def run(self):
                try:
                    # 传递进度更新回调和取消标志给任务函数
                    result = self.func(
                        progress_callback=self.progress_updated.emit,
                        cancel_flag=self.cancel_flag,
                        *self.args, **self.kwargs
                    )
                    self.finished_signal.emit(True, result)
                except Exception as e:
                    logger.error(f"后台任务执行失败: {e}", exc_info=True)
                    self.finished_signal.emit(False, None)

        try:
            app = DialogUtils._get_app_instance()

            # 取消标志（通过列表实现可变对象传递）
            cancel_flag = [False]

            # 创建进度对话框（强制设置放弃按钮）
            cancel_btn_text = "放弃" if cancelable else ""
            progress_dialog = QProgressDialog(
                label_text,
                cancel_btn_text,
                min_value,
                max_value,
                None
            )
            progress_dialog.setWindowTitle(title)
            progress_dialog.setModal(modal)
            progress_dialog.setMinimumDuration(500)  # 500ms后显示
            progress_dialog.setWindowModality(Qt.WindowModal)

            # 设置窗口图标
            try:
                default_icon = QIcon(DEFAULT_ICON_PATH)
                if not default_icon.isNull():
                    progress_dialog.setWindowIcon(default_icon)
            except Exception:
                pass

            # 创建并启动工作线程
            worker = WorkerThread(task_func, cancel_flag, *args, **kwargs)

            # 连接信号槽
            worker.progress_updated.connect(progress_dialog.setValue)
            worker.finished_signal.connect(progress_dialog.close)

            if cancelable:
                # 取消逻辑：设置取消标志并终止线程
                def on_cancel():
                    cancel_flag[0] = True
                    worker.quit()  # 终止线程
                    worker.wait(1000)  # 等待1秒，避免线程泄漏

                progress_dialog.canceled.connect(on_cancel)

            # 启动线程并显示对话框
            worker.start()
            progress_dialog.exec()

            # 等待线程结束
            worker.wait()

            # 获取结果（通过信号槽捕获）
            task_success = False
            task_result = None

            def on_task_finished(success, result):
                nonlocal task_success, task_result
                task_success = success
                task_result = result

            # 确保信号已处理
            worker.finished_signal.connect(on_task_finished)
            app.processEvents()  # 处理未完成的信号

            return task_success, task_result
        except Exception as e:
            logger.error(f"创建进度对话框失败: {e}", exc_info=True)
            return False, None


# 最终验证测试
if __name__ == "__main__":
    app = DialogUtils._get_app_instance()

    # 1. 测试信息对话框（确定按钮 + 显示详细信息按钮）
    DialogUtils.info(
        "信息提示框",
        detailed_text="这是详细信息演示\n验证两个关键点：\n1. 主按钮显示'确定'\n2. 详细信息按钮显示'显示详细信息'（点击后切换为'隐藏详细信息'）"
    )

    # 2. 测试询问对话框（确定/放弃按钮）
    question_result = DialogUtils.question("询问对话框", "请选择操作")
    if question_result == StandardButton.Ok:
        DialogUtils.info("操作结果", "您点击了'确定'按钮")
    else:
        DialogUtils.info("操作结果", "您点击了'放弃'按钮")

    # 3. 测试错误对话框（确定按钮）
    DialogUtils.error("错误提示", "测试错误对话框的确定按钮", "详细错误信息")

    # 4. 测试关于对话框（确定按钮）
    DialogUtils.about("关于MES系统", version="V2.0.0", copyright="© 2025 智能制造有限公司")

    sys.exit(app.exec())